/**
 * PLM项目 - 研发项目状态机MobX Store
 */
import { observable, action, computed, runInAction } from 'mobx-miniprogram';
const cloudHelper = require('../config/project_helpers_config').cloudHelper;
// 修改引用路径，使用静态导入
let researchService;
try {
  // 使用静态路径导入研发服务
  const ResearchService = require('../services/research_service.js');
  researchService = ResearchService.researchService;
} catch (e) {
  console.error('加载研发服务模块失败:', e);
  // 提供备用实现
  researchService = {
    getResearchDetail: async (id) => {
      console.warn('使用备用研发服务实现');
      try {
        // 尝试直接调用云函数
        return await cloudHelper.callCloudData('plm_research/detail', { id }, {
          title: '加载中',
          loading: true
        });
      } catch (err) {
        console.error('备用研发服务获取详情失败:', err);
        return {
          _id: id,
          name: '获取详情失败',
          status: 0
        };
      }
    },
    executeEvent: async (id, eventId, data = {}) => {
      console.warn('使用备用研发服务实现-执行事件');
      try {
        return await cloudHelper.callCloudData('plm_research/execute_event', {
          id,
          eventId,
          data
        }, {
          title: '处理中',
          loading: true
        });
      } catch (err) {
        console.error('备用研发服务执行事件失败:', err);
        throw err;
      }
    }
  };
}

/**
 * 角色模拟配置
 */
const ROLE_SIMULATION = {
	// 是否启用角色模拟
	ENABLED: true,
	
	// 是否只允许管理员使用模拟功能
	ADMIN_ONLY: false,
	
	// 允许模拟的角色列表
	ALLOWED_ROLES: [
		'admin',
		'research_manager',
		'director',
		'hardware_engineer',
		'software_engineer',
		'tester',
		'business_staff',
		'sample_team',
		'purchaser',
		'document_controller',
		'warehouse_keeper',
		'receptionist',
		'secretary',
		'production_supervisor',
		'production_engineer',
		'sample_manager'
	],
	
	// 是否记录模拟操作日志
	LOG_ACTIONS: true
};

/**
 * 项目状态定义 - 按研发流程状态机文档定义
 */
const PROJECT_STATUS = {
	// 基础状态
	NONE: 0,            // 初始状态
	REVIEWING: 1,       // 项目审核
	DORMANT: 2,         // 休眠
	ACTIVE: 3,          // 活动
	COMPLETED: 99,      // 完成项目
};

/**
 * 活动状态定义 - 按研发流程状态机文档定义
 */
const ACTIVE_STATE = {
	HARDWARE_CONFIRM: 'hardware_confirm',                 // 硬件确认
	HARDWARE_DESIGN_SAMPLE: 'hardware_design_sample',     // 硬件设计打样
	SW_HW_DEBUG: 'sw_hw_debug',                           // 软硬件调试
	DATA_SYNC: 'data_sync',                               // 资料同步
	TESTING: 'testing',                                   // 测试验证
	CUSTOMER_CONFIRM: 'customer_confirm',                 // 客户确认
	ORDER_PREPARATION: 'order_preparation',               // 订单准备
	PRODUCTION: 'production',                             // 生产
	PRODUCT_FEEDBACK: 'product_feedback'                  // 产品待客户反馈
};

/**
 * 子状态定义 - 按研发流程状态机文档定义
 */
const SUB_STATE = {
	// 项目审核子状态
	REVIEW_DIRECTOR: 'review_director',           // 待董事长审核
	REVIEW_MANAGER: 'review_manager',             // 待研发经理审核
	REVIEW_ASSIGN: 'review_assign',               // 项目分配
	
	// 休眠子状态
	DORMANT_REVIEW: 'dormant_review',             // 研发审核
	DORMANT_ARCHIVE: 'dormant_archive',           // 休眠归档
	
	// 硬件设计打样子状态
	HW_DESIGN: 'hw_design',                       // 硬件设计
	HW_REVIEW: 'hw_review',                       // 硬件审核
	HW_PURCHASE_SAMPLE: 'hw_purchase_sample',     // 采购打样
	HW_SAMPLE_MAKING: 'hw_sample_making',         // 样品组制样
	HW_SAMPLE_STORAGE: 'hw_sample_storage',       // 样品在库
	
	// 测试验证子状态
	TESTING_IN_PROGRESS: 'testing_in_progress',   // 测试中
	TESTING_NO_TEST: 'testing_no_test',           // 无测试审核
	
	// 客户确认子状态
	CUSTOMER_SHIPPING: 'customer_shipping',       // 寄样
	CUSTOMER_TESTING: 'customer_testing',         // 客户测试
	CUSTOMER_NO_SIGN: 'customer_no_sign',         // 无签样审核
	CUSTOMER_SAMPLE_STORAGE: 'customer_sample_storage', // 样品入库
	CUSTOMER_ARCHIVING: 'customer_archiving',     // 归档
	
	// 无签样审核子状态
	NO_SIGN_MANAGER_REVIEW: 'no_sign_manager_review', // 研发经理审核
	NO_SIGN_DIRECTOR_REVIEW: 'no_sign_director_review', // 董事长审核
	
	// 订单准备子状态
	ORDER_PENDING: 'order_pending',               // 待量产
	ORDER_REVIEW: 'order_review',                 // 订单审核
	ORDER_DOCS_SENDING: 'order_docs_sending',     // 文控发送生产资料
	ORDER_DOCS_SUPPLEMENT: 'order_docs_supplement', // 研发补充资料
	ORDER_MEETING: 'order_meeting',               // 产前会议
	ORDER_PREPARATION: 'order_preparation',       // 生产准备
	
	// 生产子状态
	PRODUCTION_IN_PROGRESS: 'production_in_progress', // 生产中
	PRODUCTION_PE_ISSUE: 'production_pe_issue',    // PE问题处理中
	PRODUCTION_RD_ISSUE: 'production_rd_issue',    // 研发问题排查
	PRODUCTION_COMPLETED: 'production_completed'   // 生产完成
};

/**
 * 状态事件定义 - 按研发流程状态机文档定义的事件
 */
const STATE_EVENTS = {
	// 项目审核事件
	SUBMIT_REQUEST: 'submit_request',              // 提交功能需求表
	DIRECTOR_APPROVE: 'director_approve',          // 董事长审核通过
	DIRECTOR_REJECT: 'director_reject',            // 董事长审核不通过
	MANAGER_APPROVE: 'manager_approve',            // 研发经理审核通过
	MANAGER_REJECT: 'manager_reject',              // 研发经理审核不通过
	PROJECT_ASSIGN_COMPLETE: 'project_assign_complete', // 提交分配
	
	// 休眠事件
	SLEEP_REQUEST: 'sleep_request',                // 业务提交休眠申请
	SLEEP_APPROVE: 'sleep_approve',                // 休眠审核通过
	SLEEP_REJECT: 'sleep_reject',                  // 休眠审核不通过
	WAKEUP_REQUEST: 'wakeup_request',              // 业务提交唤醒申请
	
	// 硬件确认事件
	HW_CONFIRM_COMPLETED: 'hw_confirm_completed',  // 硬件确认完成
	HW_EXISTING: 'hw_existing',                    // 已有硬件
	
	// 硬件设计打样事件
	HW_DESIGN_SUBMIT: 'hw_design_submit',          // 提交硬件设计审核
	HW_DESIGN_REVIEW_PASS: 'hw_design_review_pass', // 硬件审核通过
	HW_DESIGN_REVIEW_FAIL: 'hw_design_review_fail', // 硬件审核不通过
	PURCHASE_COMPLETE: 'purchase_complete',        // 采购完成
	PURCHASE_ISSUE: 'purchase_issue',              // 采购物料异常
	SAMPLE_MAKING_COMPLETE: 'sample_making_complete', // 样品制作完成
	
	// 软硬件调试事件
	DEBUG_COMPLETE: 'debug_complete',              // 调试完成
	HW_CONFIRM_AGAIN: 'hw_confirm_again',          // 重新确认硬件
	CANCEL_FUNCTION_ISSUE: 'cancel_function_issue', // 撤销功能问题
	CANCEL_ISSUE: 'cancel_issue',                  // 撤销问题申请
	
	// 资料同步事件
	SYNC_COMPLETE: 'sync_complete',                // 同步完成
	
	// 测试验证事件
	TEST_PASS: 'test_pass',                        // 测试通过
	TEST_FAIL: 'test_fail',                        // 测试不通过
	NO_TEST_APPROVE: 'no_test_approve',            // 无测试审核通过
	
	// 客户确认事件
	CUSTOMER_RECEIVED: 'customer_received',        // 客户到样
	CUSTOMER_SIGN_SAMPLE: 'customer_sign_sample',  // 签实物样
	NO_SIGN_REQUEST: 'no_sign_request',            // 业务无签样申请
	NO_SIGN_MANAGER_APPROVE: 'no_sign_manager_approve', // 研发经理审核通过
	NO_SIGN_DIRECTOR_APPROVE: 'no_sign_director_approve', // 董事长审核通过
	NO_SIGN_REJECT: 'no_sign_reject',              // 无签样审核不通过
	SAMPLE_STORAGE_CONFIRM: 'sample_storage_confirm', // 样品管理员确认
	ARCHIVE_COMPLETE: 'archive_complete',          // 归档完成
	FIND_FUNCTION_ISSUE: 'find_function_issue',    // 发现功能问题
	SOLVE_PRODUCT_ISSUE: 'solve_product_issue',    // 解决在途产品问题
	
	// 订单准备事件
	ORDER_REQUEST: 'order_request',                // 业务提交订单
	ORDER_APPROVE: 'order_approve',                // 订单审核通过
	ORDER_REJECT: 'order_reject',                  // 订单审核不通过
	DOCS_SEND_COMPLETE: 'docs_send_complete',      // 资料发送完成
	DOCS_INCOMPLETE: 'docs_incomplete',            // 资料不完整
	DOCS_SUPPLEMENT_COMPLETE: 'docs_supplement_complete', // 资料补充完成
	MEETING_COMPLETE: 'meeting_complete',          // 会议完成
	PREPARATION_COMPLETE: 'preparation_complete',  // 准备完成
	CANCEL_ORDER: 'cancel_order',                  // 取消订单
	
	// 生产事件
	PRODUCTION_ISSUE: 'production_issue',          // 生产问题反馈
	PE_ISSUE_SOLVED: 'pe_issue_solved',            // 问题解决
	RD_ISSUE_FOUND: 'rd_issue_found',              // 发现设计问题
	RD_ISSUE_SOLVED: 'rd_issue_solved',            // 研发问题解决
	PRODUCTION_COMPLETE: 'production_complete',    // 生产完成
	
	// 项目终结事件
	PROJECT_END: 'project_end'                     // 项目终结
};

/**
 * 研发状态Store
 */
export const researchStateStore = observable({
  // 当前项目
  currentProject: null,

  // 项目详情
  projectDetail: null,

  // 加载状态
  loading: false,

  // 错误信息
  error: null,

  // 当前用户角色
  currentRole: '',

  // 可用的状态事件
  availableEvents: [],

  // 历史记录
  history: [],

  // 设置当前项目
  setCurrentProject: action(function(project) {
    this.currentProject = project;
    this.loadProjectDetail(project.id || project._id);
  }),

  // 加载项目详情
  loadProjectDetail: action(async function(id) {
    if (!id) return;

    this.loading = true;
    this.error = null;

    try {
      const result = await researchService.getResearchDetail(id);
      
      runInAction(() => {
        this.projectDetail = result;
        this.loading = false;
        this._updateAvailableEvents();
      });
    } catch (err) {
      runInAction(() => {
        console.error('[研发状态Store] 加载项目详情失败:', err);
        this.error = '加载项目详情失败';
        this.loading = false;
      });
    }
  }),

  // 执行状态事件
  executeEvent: action(async function(eventId, data = {}) {
    if (!this.projectDetail || !this.projectDetail._id) {
      this.error = '项目不存在';
      return false;
    }

    this.loading = true;
    this.error = null;

    try {
      const result = await researchService.executeEvent(
        this.projectDetail._id,
        eventId,
        data
      );
      
      runInAction(() => {
        // 更新项目详情
        this.projectDetail = result.project;
        this.loading = false;
        this._updateAvailableEvents();
      });

      return true;
    } catch (err) {
      runInAction(() => {
        console.error('[研发状态Store] 执行事件失败:', err);
        this.error = '执行事件失败: ' + (err.message || '未知错误');
        this.loading = false;
      });
      return false;
    }
  }),

  // 更新可用事件列表
  _updateAvailableEvents: action(function() {
    // 这里根据当前项目状态和用户角色确定可用的事件
    // 具体实现根据业务逻辑定制
    if (!this.projectDetail) {
      this.availableEvents = [];
      return;
    }

    // 简单示例，实际应该根据状态机规则来确定
    this.availableEvents = Object.keys(STATE_EVENTS);
  }),

  // 设置当前用户角色
  setCurrentRole: action(function(role) {
    this.currentRole = role;
    this._updateAvailableEvents();
  })
});

// 导出常量
export {
  PROJECT_STATUS,
  ACTIVE_STATE,
  SUB_STATE,
  STATE_EVENTS,
  ROLE_SIMULATION
}; 